/**
 * @p.md
 * 
 * EventStream 模块，实现事件发布订阅系统
 */
import { PID } from './pid';
import { ActorSystem } from './actorSystem';

/**
 * 事件订阅者类型，可以是 PID 或函数
 */
export type Subscriber = PID | ((event: any) => void);

/**
 * 订阅项，包含订阅者和事件类型
 */
interface Subscription {
  eventType: string | Function;
  handler: (event: any) => void;
}

/**
 * 事件流类，实现发布-订阅模式
 */
export class EventStream {
  /**
   * 订阅列表
   */
  private subscriptions: Subscription[] = [];
  
  /**
   * 构造函数
   * @param system 关联的 Actor 系统
   */
  constructor(private readonly system: ActorSystem) {}

  /**
   * 订阅事件
   * @param eventType 事件类型
   * @param handler 处理函数
   */
  subscribe<T>(eventType: string | Function, handler: (event: T) => void): void {
    console.log(`[EVENT_STREAM] 订阅事件类型: ${typeof eventType === 'string' ? eventType : eventType.name}`);
    this.subscriptions.push({ eventType, handler });
  }

  /**
   * 取消订阅事件
   * @param eventType 事件类型
   * @param handler 处理函数
   */
  unsubscribe<T>(eventType: string | Function, handler: (event: T) => void): void {
    console.log(`[EVENT_STREAM] 取消订阅事件类型: ${typeof eventType === 'string' ? eventType : eventType.name}`);
    const index = this.subscriptions.findIndex(
      sub => sub.eventType === eventType && sub.handler === handler
    );
    if (index !== -1) {
      this.subscriptions.splice(index, 1);
    }
  }

  /**
   * 发布事件
   * @param event 事件对象
   */
  publish(event: any): void {
    console.log(`[EVENT_STREAM] 发布事件:`, event);
    
    // 获取事件类型名称
    const eventTypeName = typeof event === 'string' ? event : event?.constructor?.name;
    if (!eventTypeName) {
      console.warn(`[EVENT_STREAM] 无法确定事件类型:`, event);
      return;
    }
    
    console.log(`[EVENT_STREAM] 事件类型: ${eventTypeName}`);
    
    // 查找匹配事件类型的订阅
    const matchingSubscriptions = this.subscriptions.filter(sub => {
      if (typeof sub.eventType === 'string') {
        return sub.eventType === eventTypeName;
      } else {
        // 检查事件类型是否匹配
        try {
          if (sub.eventType === Object) {
            return true;
          }
          
          // 如果事件是一个对象，检查它的类型
          if (typeof event === 'object' && event !== null) {
            // 如果事件有 type 属性，使用它进行匹配
            if ('type' in event) {
              return (event as any).type === (sub.eventType as any).name;
            }
            
            // 如果事件有 constructor，使用它进行匹配
            if (event.constructor && event.constructor.name) {
              return event.constructor.name === (sub.eventType as any).name;
            }
          }
          
          // 如果都不匹配，返回 false
          return false;
          
        } catch (error) {
          console.warn(`[EVENT_STREAM] 类型检查失败:`, error);
          return false;
        }
      }
    });
    
    console.log(`[EVENT_STREAM] 找到 ${matchingSubscriptions.length} 个匹配的订阅`);
    
    // 调用所有匹配的处理函数
    matchingSubscriptions.forEach(sub => {
      try {
        sub.handler(event);
      } catch (error) {
        console.error(`[EVENT_STREAM] 处理事件时出错:`, error);
      }
    });
  }

  /**
   * 获取当前订阅数量
   * @returns 订阅数量
   */
  subscriptionCount(): number {
    return this.subscriptions.length;
  }

  /**
   * 清除所有订阅
   */
  clearSubscriptions(): void {
    this.subscriptions = [];
  }
}

/**
 * 预定义事件类型
 */
export namespace Events {
  /**
   * Actor 启动事件
   */
  export class ActorStarted {
    constructor(public readonly pid: PID) {}
  }

  /**
   * Actor 停止事件
   */
  export class ActorStopped {
    constructor(public readonly pid: PID) {}
  }

  /**
   * Actor 重启事件
   */
  export class ActorRestarted {
    constructor(
      public readonly pid: PID,
      public readonly reason: Error
    ) {}
  }

  /**
   * 无效信件事件 (Dead Letter)
   */
  export class DeadLetter {
    constructor(
      public readonly pid: PID,
      public readonly message: any,
      public readonly sender?: PID
    ) {}
  }

  /**
   * 系统错误事件
   */
  export class SystemError {
    constructor(
      public readonly message: string,
      public readonly error: Error
    ) {}
  }

  /**
   * 系统关闭事件
   */
  export class SystemShutdown {
    constructor() {}
  }
}

/**
 * 默认事件流工厂，提供创建默认事件流的方法
 */
export const EventStreams = {
  /**
   * 创建默认的事件流
   * @param system Actor 系统
   * @returns 事件流实例
   */
  createEventStream(system: ActorSystem): EventStream {
    return new EventStream(system);
  }
};

/**
 * DeadLetter 事件，当消息无法送达时触发
 */
export class DeadLetterEvent {
  /**
   * 创建一个新的DeadLetterEvent
   * @param target 目标PID字符串
   * @param hasSender 是否有发送者
   * @param sender 发送者PID字符串
   * @param messageType 消息类型
   */
  constructor(
    public readonly target: string,
    public readonly hasSender: boolean,
    public readonly sender: string,
    public readonly messageType: string
  ) {}
} 